{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 第27章预训练语言模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 习题27.1\n",
    "&emsp;&emsp;设计基于双向LSTM的预训练语言模型，假设下游任务是文本分类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答：**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答思路：**\n",
    "\n",
    "1. 结合习题25.4可给出双向LSTM模型\n",
    "2. 给出下游任务是文本分类的模型微调的描述\n",
    "3. 自编程实现双向LSTM的预训练语言模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答步骤：**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第1步：结合习题25.4可给出双向LSTM模型**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;前向的LSTM的隐层（状态）是\n",
    "$$\n",
    "h_t^f = \\text{LSTM}_f (x_t, h_{t-1}^f)\n",
    "$$\n",
    "后向的LSTM的隐层（状态）是\n",
    "$$\n",
    "h_t^b = \\text{LSTM}_b (x_t, h_{t+1}^b)\n",
    "$$\n",
    "其中，$\\text{LSTM}_f$ 和 $\\text{LSTM}_b$ 分别表示前向LSTM和后向LSTM，$h_{t-1}^f$ 和 $h_{t+1}^b$ 分别表示前向LSTM和后向LSTM的上一个位置的隐藏状态。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "两者的拼接是\n",
    "$$\n",
    "h_t = [h_i^f; h_i^b]\n",
    "$$\n",
    "其中，；表示两个向量的拼接。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "p_t = \\text{softmax}(V \\cdot h_t + c) \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第2步：给出下游任务是文本分类的模型微调的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第498页下游任务是文本分类的模型微调的描述：\n",
    "> &emsp;&emsp;假设下游任务是文本分类，输入单词序列是$x' = x_0, x_1, \\cdots, x_l$，输出是类别 $y$，计算条件概率 $P(y|x_0,x_1,\\cdots, x_l)$：\n",
    "> $$\n",
    "P_{\\theta,\\phi} = \\text{softmax} ({W_y}^T h_{cls}^{(L)}) = \\frac{\\exp {w_y^T \\cdot h_{cls}^{(L)}}}{\\sum_{y'} \\exp {w_{y'}^T \\cdot h_{cls}^{(L)}}} \\tag{27.30}\n",
    "$$\n",
    ">其中，$h_{cls}^{(L)}$ 是第 $L$ 层的类别特殊字符\\<cls\\>的表示向量，$W_y$ 是类别的权重矩阵，$\\phi$ 表示分类的参数。这时单词序列 $x_0, x_1, \\cdots ,x_l$ 是一个句子或一段文章，以特殊字符\\<cls\\>开始，以特殊字符\\<sep\\>结束。\n",
    "> 微调损失函数为：\n",
    "> $$\n",
    "L_{\\text{FT}} = -\\log P_{\\theta,\\phi}(y|x')\n",
    "$$\n",
    "> 微调中，预训练模型的参数 $\\theta$ 作为初始值，在这个过程中进一步得到学习，以帮助更好地分类；同时分类的参数 $\\phi$ 也得到学习。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第3步：自编程实现双向LSTM的预训练语言模型**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.dataset import random_split\n",
    "from torchtext.data.functional import to_map_style_dataset\n",
    "from torchtext.data.utils import get_tokenizer\n",
    "from torchtext.datasets import AG_NEWS\n",
    "from torchtext.vocab import build_vocab_from_iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 得到词向量\n",
    "train_iter = AG_NEWS(split='train', root='./data')\n",
    "tokenizer = get_tokenizer('basic_english')\n",
    "def yield_tokens(data_iter):\n",
    "    for _, text in data_iter:\n",
    "        yield tokenizer(text)\n",
    "\n",
    "\n",
    "vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=[\"<unk>\"])\n",
    "vocab.set_default_index(vocab[\"<unk>\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_pipeline = lambda x : vocab(tokenizer(x))\n",
    "label_pipeline = lambda x : int(x) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "def collate_batch(batch):\n",
    "    label_list, text_list, offsets = [], [], [0]\n",
    "    for (_label, _text) in batch:\n",
    "        label_list.append(label_pipeline(_label))\n",
    "        processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)\n",
    "        text_list.append(processed_text)\n",
    "        offsets.append(processed_text.size(0))\n",
    "    label_list = torch.tensor(label_list, dtype=torch.int64)\n",
    "    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)\n",
    "    text_list = torch.cat(text_list)\n",
    "    return label_list.to(device), text_list.to(device), offsets.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 加载AG_NEWS数据集\n",
    "train_iter, test_iter = AG_NEWS(root='./data')\n",
    "train_dataset = to_map_style_dataset(train_iter)\n",
    "test_dataset = to_map_style_dataset(test_iter)\n",
    "num_train = int(len(train_dataset) * 0.95)\n",
    "split_train_, split_valid_ = \\\n",
    "    random_split(train_dataset, [num_train, len(train_dataset) - num_train])\n",
    "\n",
    "BATCH_SIZE = 256\n",
    "train_dataloader = DataLoader(split_train_, batch_size=BATCH_SIZE,\n",
    "                              shuffle=True, collate_fn=collate_batch)\n",
    "valid_dataloader = DataLoader(split_valid_, batch_size=BATCH_SIZE,\n",
    "                              shuffle=True, collate_fn=collate_batch)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE,\n",
    "                             shuffle=True, collate_fn=collate_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TextClassifier(nn.Module):\n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_classes):\n",
    "        super().__init__()\n",
    "        self.embedding = nn.EmbeddingBag(vocab_size, embedding_dim, sparse=False)\n",
    "        # 使用双向LSTM\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, bidirectional=True, batch_first=True)\n",
    "        # 使用线性函数进行文本分类任务\n",
    "        self.fc = nn.Linear(hidden_dim * 2, num_classes)\n",
    "        self.init_weights()\n",
    "    \n",
    "    def init_weights(self):\n",
    "        initrange = 0.5\n",
    "        self.embedding.weight.data.uniform_(-initrange, initrange)\n",
    "        self.fc.weight.data.uniform_(-initrange, initrange)\n",
    "        self.fc.bias.data.zero_()\n",
    "        \n",
    "    def forward(self, text, offsets):\n",
    "        embedded = self.embedding(text, offsets)\n",
    "        x, _ = self.lstm(embedded)\n",
    "        x = self.fc(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "EMBED_DIM = 64\n",
    "HIDDEN_DIM = 64\n",
    "NUM_CLASSES = 4\n",
    "LEARNING_RATE = 1e-2\n",
    "NUM_EPOCHS = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = TextClassifier(len(vocab), EMBED_DIM, HIDDEN_DIM, NUM_CLASSES).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(dataloader):\n",
    "    model.train()\n",
    "\n",
    "    for idx, (label, text, offsets) in enumerate(dataloader):\n",
    "        optimizer.zero_grad()\n",
    "        predicted_label = model(text, offsets)\n",
    "        loss = criterion(predicted_label, label)\n",
    "        loss.backward()\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1)\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(dataloader):\n",
    "    model.eval()\n",
    "    total_acc, total_count = 0, 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for idx, (label, text, offsets) in enumerate(dataloader):\n",
    "            predicted_label = model(text, offsets)\n",
    "            loss = criterion(predicted_label, label)\n",
    "            total_acc += (predicted_label.argmax(1) == label).sum().item()\n",
    "            total_count += label.size(0)\n",
    "    return total_acc/total_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用交叉熵损失函数\n",
    "criterion = nn.CrossEntropyLoss().to(device)\n",
    "# 设置优化器\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------------------------------------------------------\n",
      "| end of epoch   1 | time:  5.74s | valid accuracy     92.1% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   2 | time:  5.49s | valid accuracy     91.2% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   3 | time:  5.36s | valid accuracy     90.9% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   4 | time:  5.25s | valid accuracy     90.5% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   5 | time:  5.20s | valid accuracy     90.5% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   6 | time:  5.21s | valid accuracy     90.5% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   7 | time:  5.22s | valid accuracy     90.6% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   8 | time:  5.20s | valid accuracy     90.4% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch   9 | time:  5.22s | valid accuracy     90.0% \n",
      "-----------------------------------------------------------\n",
      "-----------------------------------------------------------\n",
      "| end of epoch  10 | time:  5.21s | valid accuracy     90.0% \n",
      "-----------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, NUM_EPOCHS + 1):\n",
    "    epoch_start_time = time.time()\n",
    "    train(train_dataloader)\n",
    "    accu_val = evaluate(valid_dataloader)\n",
    "    print('-' * 59)\n",
    "    print('| end of epoch {:3d} | time: {:5.2f}s | '\n",
    "          'valid accuracy {:8.1f}% '.format(epoch,\n",
    "                                           time.time() - epoch_start_time,\n",
    "                                           accu_val * 100))\n",
    "    print('-' * 59)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ag_news_label = {1: \"World\",\n",
    "                 2: \"Sports\",\n",
    "                 3: \"Business\",\n",
    "                 4: \"Sci/Tec\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(text, text_pipeline):\n",
    "    with torch.no_grad():\n",
    "        text = torch.tensor(text_pipeline(text))\n",
    "        output = model(text, torch.tensor([0]))\n",
    "        return output.argmax(1).item() + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a Sci/Tec news\n"
     ]
    }
   ],
   "source": [
    "ex_text_str = \"\"\"\n",
    "Our younger Fox Cubs (Y2-Y4) also had a great second experience \n",
    "of swimming competition in February when they travelled over to \n",
    "NIS at the end of February to compete in the SSL Development \n",
    "Series R2 event. For students aged 9 and under these SSL \n",
    "Development Series events are a great introduction to \n",
    "competitive swimming, focussed on fun and participation whilst \n",
    "also building basic skills and confidence as students build up \n",
    "to joining the full SSL team in Year 5 and beyond.\n",
    "\"\"\"\n",
    "model = model.to(\"cpu\")\n",
    "print(\"This is a %s news\" %ag_news_label[predict(ex_text_str, text_pipeline)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 习题27.2\n",
    "&emsp;&emsp;假设GPT微调的下游任务是两个文本的匹配，写出学习的目标函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出GPT模型的描述\n",
    "2. 给出文本匹配任务的描述\n",
    "3. 写出GPT微调的下游任务是两个文本匹配时的学习的目标函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第1步：给出GPT模型的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第501页GPT模型的描述：\n",
    "> &emsp;&emsp;GPT模型的输入是单词序列，可以是一个句子或一段文章。首先经过输入层，产生初始的单词表示向量的序列。之后经过 $L$ 个Transformer解码层，得到单词表示向量的序列，GPT模型的输出是在单词序列各个位置上的条件概率。  \n",
    "> &emsp;&emsp;GPT预训练时，通过极大似然估计学习模型的参数。\n",
    "> $$\n",
    "L_{\\text{train}} = - \\sum_{i = 1}^n \\log P_{\\theta}(x_i | x_1, x_2, \\cdots, x_{i - 1})\n",
    "$$\n",
    "> &emsp;&emsp;GPT微调时，通过优化下游任务的目标函数，进一步调节模型的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第2步：给出文本匹配任务的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第499页文本匹配任务的描述：\n",
    "> &emsp;&emsp;如果下游任务是文本匹配，如判断两句话是否形成一问一答。输入单词序列是 $x_0, x_1, \\cdots, x_l$，输出是类别 $y$，仍然计算条件概率 $P(y | x_0, x_1, \\cdots, x_l)$。类别有两类，表示匹配或不匹配。这时单词序列 $x_0, x_1, \\cdots, x_l$ 是两个单词序列合成的序列，如一个问句和一个答句合并而成。以特殊字符\\<cls\\>开始，中间以特殊字符\\<sep\\>间隔，最后以特殊字符\\<sep\\>结束。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第3步：写出GPT微调的下游任务是两个文本匹配时的学习的目标函数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;假设分别有两个文本，矩阵$X_1 = (x_1^{(1)}, x_2^{(1)}, \\cdots, x_{m - 1}^{(1)})$和矩阵$X_2 = (x_{m + 1}^{(2)}, x_{m + 2}^{(2)}, \\cdots, x_{m + n - 1}^{(2)})$分别表示两个文本的词嵌入的序列，矩阵$E_1=(e_1^{(1)}, e_2^{(1)}, \\cdots, e_{m - 1}^{(1)})$和矩阵$E_2=(e_{m + 1}^{(2)}, e_{m + 2}^{(2)}, \\cdots, e_{m + n - 1}^{(2)})$分别表示两个文本的位置嵌入序列。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;经过输入层，产生初始的单词表示向量的序列，分别表示为\n",
    "$$\n",
    "H_1^{0} = X_1 + E_1 \\\\\n",
    "H_2^{0} = X_2 + E_2\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;将两个句子分别作为前句或后句，构造两个完整的文本：  \n",
    "- 文本1：\\<cls\\>, $x_1^{(1)}, x_2^{(1)}, \\cdots, x_{m - 1}^{(1)},$ \\<sep\\>, $x_{m + 1}^{(2)}, x_{m + 2}^{(2)}, \\cdots, x_{m + n - 1}^{(2)}$, \\<sep\\>\n",
    "- 文本2：\\<cls\\>, $x_{m + 1}^{(2)}, x_{m + 2}^{(2)}, \\cdots, x_{m + n - 1}^{(2)},$ \\<sep\\>, $x_1^{(1)}, x_2^{(1)}, \\cdots, x_{m - 1}^{(1)}$, \\<sep\\>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分别进行GPT预训练模型：\n",
    "$$\n",
    "H_1^{(L)} = \\text{transformer_decoder}([H_1^{(0)};H_2^{(0)}]) \\\\\n",
    "H_2^{(L)} = \\text{transformer_decoder}([H_2^{(0)};H_1^{(0)}]) \\\\\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将得到单词表示向量的序列进行融合，使用线性层得到GPT模型的输出：\n",
    "$$\n",
    "H'^{(L)} = H_1^{(L)} \\oplus H_2^{(L)} = (h_1'^{(L)}, h_2'^{(L)}, \\cdots h_{m + n}'^{(L)}) \\\\\n",
    "P_{\\theta}(x_i |x_1, x_2, \\cdots, x_{i - 1}) = \\text{softmax} (W_x^T h_i'^{(L)}) = \\frac{\\exp \\left ( w_{x_i}^T \\cdot h_i'^{(L)} \\right )}{\\displaystyle \\sum_{x_i} \\exp \\left (w_{x_i}^T \\cdot h_i'^{(L)} \\right )}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在预训练阶段，目标函数是\n",
    "$$\n",
    "L_{\\text{PT}} = - \\sum_{i=1}^{m + n} \\log P_{\\theta}(x_i |x_1, x_2, \\cdots, x_{i - 1})\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;微调时，下游任务是文本匹配，输入的单词序列是两个文本合的序列$x_1, x_2, \\cdots,x_{m + n}$，输出是类别$y$，以特殊字符\\<cls\\>开始，中间以特殊字符\\<sep\\>间隔，最后以特殊字符\\<sep\\>结束。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可得到微调的目标函数为\n",
    "$$\n",
    "L_{\\text{LM}} = - \\frac{1}{m + n} \\sum_{i = 1}^{m + n} \\log P_{\\theta}(y|x_1, x_2, \\cdots, x_{i - 1})\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 习题27.3\n",
    "&emsp;&emsp;设计一个2层卷积神经网络编码器和2层卷积神经网络解码器组成的自动编码器（使用第28章介绍的转置卷积）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出自动编码器的原理\n",
    "2. 自编程实现2层卷积自动编码器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第1步：自动编码器的原理**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第493页关于自动编码器的描述：\n",
    "> &emsp;&emsp;自动编码器（auto encoder）是用于数据表示的无监督学习的一种神经网络。自动编码器由编码器网络和解码器网络组成。\n",
    "> 最基本的情况下，编码器和解码器分别都是一层神经网络\n",
    "> $$\n",
    "z = F(x) = a(W_E x + b_E) \\\\\n",
    "y = G(z) = a(W_D x + b_D)\n",
    "$$\n",
    "> 其中，$W_E, W_D$是权重矩阵，$b_E, b_D$是偏置向量，$a(\\cdot)$是激活函数。  \n",
    "> &emsp;&emsp;学习时，目标函数是\n",
    "> $$\n",
    "L = \\frac{1}{N} \\sum_{i=1}^N L(x_i, y_i) = \\frac{1}{N} \\sum_{i = 1}^N L(x_i, G(F(x_i)))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第2步：自编程实现2层卷积自动编码器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.transforms as transforms\n",
    "import tqdm\n",
    "from matplotlib import pyplot as plt\n",
    "from torch import optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.datasets import mnist\n",
    "from torchviz import make_dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AutoEncoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(AutoEncoder, self).__init__()\n",
    "        # 2层卷积神经网络编码器\n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Conv2d(1, 16, 3, 2, 1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(16, 32, 3, 2, 1),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        # 2层卷积神经网络解码器\n",
    "        self.decoder = nn.Sequential(\n",
    "            # 使用转置卷积\n",
    "            nn.ConvTranspose2d(32, 16, 3, 2, 1, output_padding=1),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            nn.ConvTranspose2d(16, 1, 3, 2, 1, output_padding=1),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.encoder(x)\n",
    "        x = self.decoder(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "# 使用MNIST数据集\n",
    "train_set = mnist.MNIST('./data', transform=transforms.ToTensor(), train=True, download=True)\n",
    "test_set = mnist.MNIST('./data', transform=transforms.ToTensor(), train=False, download=True)\n",
    "train_dataloader = DataLoader(train_set, batch_size=32, shuffle=True)\n",
    "test_dataloader = DataLoader(test_set, batch_size=8, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = AutoEncoder().to(device)\n",
    "\n",
    "# 设置损失函数\n",
    "criterion = nn.MSELoss()\n",
    "# 设置优化器\n",
    "optimizer = optim.Adam(model.parameters(), lr=1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AutoEncoder(\n",
       "  (encoder): Sequential(\n",
       "    (0): Conv2d(1, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
       "    (3): ReLU()\n",
       "  )\n",
       "  (decoder): Sequential(\n",
       "    (0): ConvTranspose2d(32, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): ConvTranspose2d(16, 1, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
       "    (3): Sigmoid()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 显示模型结构\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 175.31it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 188.10it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 188.67it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 187.49it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 188.35it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 186.48it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 187.44it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 188.00it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:09<00:00, 188.76it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1875/1875 [00:10<00:00, 187.21it/s]\n"
     ]
    }
   ],
   "source": [
    "# 模型训练\n",
    "EPOCHES = 10\n",
    "for epoch in range(EPOCHES):\n",
    "    for img, _ in tqdm.tqdm(train_dataloader, ):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        img = img.to(device)\n",
    "        out = model(img)\n",
    "        loss = criterion(out, img)\n",
    "        loss.backward()\n",
    "\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x200 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x200 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x200 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 将生成图片和原始图片进行对比\n",
    "for i, data in enumerate(test_dataloader):\n",
    "    img, _ = data\n",
    "    img = img.to(device)\n",
    "    model = model.to(device)\n",
    "    img_new = model(img).detach().cpu().numpy()\n",
    "    img = img.cpu().numpy()\n",
    "    plt.figure(figsize=(8, 2))\n",
    "    for j in range(8):\n",
    "        plt.subplot(2, 8, j + 1)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(img_new[j].squeeze())\n",
    "        plt.subplot(2, 8, 8 + j + 1)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(img[j].squeeze())\n",
    "    if i >= 2:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model_structure(model, device):\n",
    "    x = torch.randn(1, 1, 28, 28).requires_grad_(True).to(device)\n",
    "    y = model(x)\n",
    "    vise = make_dot(y, params=dict(list(model.named_parameters()) + [('x', x)]))\n",
    "    vise.format = \"png\"\n",
    "    vise.directory = \"./data\"\n",
    "    vise.view(\"2-Layer-CNN-AutoEncoder-Struction\", cleanup=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 保存模型架构图\n",
    "save_model_structure(model, device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 习题27.4\n",
    "\n",
    "&emsp;&emsp;证明当编码器和解码器都是线性函数时，主成分分析可以作为自动编码器学习的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出主成分分析的定义\n",
    "2. 给出自动编码器学习过程\n",
    "3. 证明当编码器和解码器都是线性函数时，主成分分析可以作为自动编码器学习的方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第1步：主成分分析的定义**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第250页主成分分析的基本思想\n",
    "> &emsp;&emsp;主成分分析中，首先对给定数据进行规范化，使得数据每一变量的平均值为0，方差为1，之后对数据进行正交变换，原来由线性相关变量表示的数据通过正交变换变成由若干个线性无关的新变量表示的数据。新变量是可能的正交变换中变量的方差的和（信息保存）最大的，方差表示在新变量上信息的大小。将新变量依次称为第一主成分、第二主成分等。这就是主成分分析的基本思想。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第266页算法16.1主成分分析算法\n",
    "> **算法16.1（主成分分析算法）**  \n",
    "> 输入：$m \\times n$样本矩阵$X$，其每一行元素的均值为零；  \n",
    "> 输出：$k \\times n$样本主成分矩阵$Y$。  \n",
    "> 参数：主成分个数$k$  \n",
    "> （1）构造新的$n \\times m$矩阵\n",
    "> $$\n",
    "X' = \\frac{1}{\\sqrt{n - 1}} X^T\n",
    "$$\n",
    "> $X'$每一列的均值为零。  \n",
    "> （2）对矩阵$X'$进行截断奇异值分解，得到\n",
    "> $$\n",
    "X' = U \\Sigma V^T\n",
    "$$\n",
    "> 有$k$个奇异值、奇异向量。矩阵$V$的前$k$列构成$k$个样本主成分。  \n",
    "> （3）求$k \\times n$样本主成分矩阵\n",
    "> $$\n",
    "Y = V^T X\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第2步：自动编码器学习过程**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第501页关于自动编码器的描述：\n",
    "> &emsp;&emsp;自动编码器是用于数据表示的无监督学习的一种神经网络。自动编码器由编码器网络和解码器网络组成。学习时编码器将输入向量转换为中间表示向量，解码器再将中间表示向量转换为输出向量。编码器和解码器可以是\n",
    "> $$\n",
    "z = F(x) = a(W_E x + b_E) \\\\\n",
    "y = G(z) = a(W_D z + b_D)\n",
    "$$\n",
    "> 学习的目标是尽量使输出向量和输入向量保持一致，或者说重建输入向量。认为学到的中间表示向量就是数据的表示。\n",
    "> $$\n",
    "L = \\frac{1}{N} \\sum_{i = 1}^N L(x_i, G(F(x_i)))\n",
    "$$\n",
    "> 学习的算法一般是梯度下降。自动编码器学习实际进行的是对数据的压缩。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第3步：证明当编码器和解码器都是线性函数时，主成分分析可以作为自动编码器学习的方法**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;假设给定样本矩阵$X = (x_1, x_2, \\cdots, x_N)$，根据主成分分析算法，可以得到主成分为$K$个对应的单位特征向量$V$，样本主成分矩阵$Y$满足\n",
    "$$\n",
    "Y = V^T \\cdot X\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样，样本主成分矩阵$Y$可以作为样本矩阵$X$的低维表示，$V$维度是$N \\times K$，其中$V = (v_1, v_2, \\cdots, v_N)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据自动编码器中的编码阶段，编码器对数据进行压缩，当编码器是线性函数时，可用主成分矩阵$Y$表示编码器的输出，即\n",
    "$$\n",
    "z = F(x) = W_E x + b_E = V^T \\cdot x\n",
    "$$\n",
    "其中$W_E = V^T, b_E = 0$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;在解码阶段，解码器通过解压可以得到原始数据的近似，当解码器是线性函数时，可用单位特征向量$V$表示$W_D$，即\n",
    "$$\n",
    "y = G(z) = W_D \\cdot z + b_D = V \\cdot z \n",
    "$$\n",
    "其中$W_D = V, b_D = 0$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;综上所述，当损失函数是平方损失函数时，自动编码器学习的目标函数是\n",
    "$$\n",
    "\\begin{aligned}\n",
    "L \n",
    "&= \\frac{1}{N} \\sum_{i=1}^N \\| x_i - G(F(x_i)) \\| \\\\\n",
    "&= \\frac{1}{N} \\sum_{i=1}^N \\| x_i - v_i \\cdot (v_i^T \\cdot x_i) \\| \\\\\n",
    "&= \\frac{1}{N} \\sum_{i=1}^N \\| x_i - v_i v_i^T x_i \\|\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;由于单位特征向量$V$可以使得样本矩阵$X$的所有线性变换中方差最大，故单位向量特征$V$能够使目标函数最小，因此，当编码器和解码器都是线性函数，且$b_E = b_D = 0$时，主成分分析可以作为自动编码器的学习方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 习题27.5\n",
    "\n",
    "&emsp;&emsp;解释为什么BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出BERT预训练中的掩码语言模型化描述\n",
    "2. 给出去噪自动编码器的原理\n",
    "3. 解释BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的原因"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第1步：BERT预训练中的掩码语言模型化的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第497页关于BERT预训练中的掩码语言模型化的描述：\n",
    "> &emsp;&emsp;BERT模型的预训练由两部分组成，掩码语言模型化和下句预测。掩码语言模型化的目标是复原输入单词序列中被掩码的单词。可以看作是去噪自动编码器学习，对被掩码的单词独立地进行复原。掩码单词序列表示为$\\tilde{x}$。  \n",
    "> &emsp;&emsp;掩码语言模型化在每一个掩码位置计算条件概率：\n",
    "> $$\n",
    "P_{\\theta} (x_i | \\tilde{x}_0, \\tilde{x}_1, \\cdot, \\tilde{x}_{m + n}) = \\text{softmax} \\left( W_x^T h_i^{(L)} \\right) = \\frac{\\exp \\left( w_{x_i}^T \\cdot h_i^{(L)} \\right)}{\\displaystyle \\sum_{x'_i} \\exp \\left( w_{x_i}^T \\cdot h_i^{(L)} \\right)}\n",
    "$$\n",
    "> 假设第$i$个位置是掩码位置，$h_i^{(L)}$是在第$L$层第$i$个位置的表示，$x_i$是预测的单词，$W_{x}$是单词的权重矩阵。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第2步：去噪自动编码器的原理**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第501页去噪自动编码器的描述：\n",
    "> &emsp;&emsp;去噪自动编码器是自动编码器的一种扩展，去噪自动编码器不仅可以用于数据表示学习，而且可以用户数据去噪。学习时首先根据对输入向量进行的随机变化，得到有噪声的输入向量。编码器将有噪声的输入向量转换为中间表示向量，解码器再将中间表示向量转换为输出向量。编码器、解码器、目标函数分别是\n",
    "> $$\n",
    "z = F(x) = a(W_E \\tilde{x} + b_E) \\\\\n",
    "y = G(z) = a(W_D z + b_D) \\\\\n",
    "L = \\frac{1}{N} \\sum_{i = 1}^N L(x_i, G(F(\\tilde(x)_i)))\n",
    "$$\n",
    "> 学习的目标是尽量使输出向量和原始输入向量保持一致，或者说重建原始输入向量。因为学习的目标是排除噪声的干扰重建数据，去噪自动编码器能更有效地学到数据的主要特征。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第3步：解释BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的原因**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;BERT在预训练阶段，输入序列中的一些单词被随机遮掩，得到有噪声的输入向量，模型需要预测这些单词。这个过程类似于去噪自动编码器的学习过程，其中模型需要从缺失的或噪声的数据中重构原始数据。因此，掩码语言模型化提供了一些“噪音”，让模型学会从不完整的输入中推断出缺失的信息，从而提高模型的泛化能力。这也就说明了BERT预训练中的掩码语言模型化是基于去噪自动编码器原理的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 习题27.6\n",
    "\n",
    "&emsp;&emsp;比较BERT与Transformer编码器在模型上的异同。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答思路：**  \n",
    "\n",
    "1. 给出BERT的模型描述\n",
    "2. 给出Transformer编码器的模型描述\n",
    "3. 比较BERT与Transformer编码器在模型上的异同"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解答步骤：**   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第1步：BERT模型的描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第495页关于BERT的描述：\n",
    "> &emsp;&emsp;BERT是双向Transformer编码器表示（Bidirectional Encoder Representations from Transformers）的缩写。BERT的模型基于Transformer的编码器，是双向语言模型。BERT的预训练主要是掩码语言模型化，使用大规模语料基于自去噪自动编码器原理进行模型的参数估计，学习的目标是复原给定的掩码单词序列中被掩码的每一个单词。学习和预测都是非自回归过程（Non-autoregressive process）。\n",
    "> &emsp;&emsp;每一个单词序列是一个句子或一段文章。首先经过输入层，产生初始的单词表示向量的序列，记作矩阵$H^{(0)}$：\n",
    "> $$\n",
    "H^{(0)} = X + S + E \\tag{27.22}\n",
    "$$\n",
    "> 其中，矩阵$X$表示单词的词嵌入的序列$X = (x_0, x_1, \\cdots, x_{m + n})$；矩阵$E$表示单词的位置嵌入的序列$E=(e_0, e_1, \\cdots, e_{m + n})$；矩阵$S$是区别前后单词的标记序列$S=(a, a, \\cdots, a, b, b, \\cdots, b)$，含有$m + 1$个向量$a$和$n$个向量$b$。$X,E,S,H^{(0)}$是$d \\times (m + n + 1)$矩阵，设词嵌入、位置嵌入、标记向量的维度是$d$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第502页BERT模型的描述：\n",
    "> &emsp;&emsp;BERT模型的输入是两个合并的单词序列。首先经过输入层，产生初始的单词表示向量的序列。之后经过$L$个Transformer编码层，得到单词的表示向量的序列。BERT模型的输出是在单词序列的各个位置上的条件概率。  \n",
    "> &emsp;&emsp;BERT模型的预训练由掩码语言模型化和下句预测组成。掩码语言模型化的目标是复原输入单词序列中被掩码的单词。下句预测的目标是判断输入单词序列是否来自同一篇文章。预训练以掩码语言模型化为主，其损失函数是\n",
    "> $$\n",
    "L_1 = - \\sum_{i = 0}^{m + n} \\delta_i \\log P_{\\theta} (x_i | \\tilde{x}_0, \\tilde{x}_1, \\cdots, \\tilde{x}_{m + n})\n",
    "$$\n",
    "> &emsp;&emsp;BERT微调时，通过优化下游任务的目标函数，进一步调节模型的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第2步：Transformer编码器的模型描述**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第476页关于Transformer编码器的描述：  \n",
    "> &emsp;&emsp;Transformer（转换器）由编码器和解码器组成。编码器有1个输入层、6个编码层（一般是$L$层）。解码器有1个输入层、6个解码层、1个输出层。编码器的输入层与第1个编码层连接，第1个编码层再与第2个编码层连接，依次连接，直到第6个编码层。解码器的输入层与第1个解码层连接，第1个解码层再与第2个解码层连接，依次连接，直到第6个解码层。第6个解码层再与输出层连接。第6个编码层与各个解码层之间也有连接。  \n",
    "> &emsp;&emsp;编码器的6个编码层将输入单词序列进行转换，得到中间表示序列。  \n",
    "> &emsp;&emsp;编码器的6个编码层有相同的结构，每一个编码层由自注意力子层和前馈网络子层两部分组成。  \n",
    "> &emsp;&emsp;在编码器的输入层，输入序列的各个位置有单词的词嵌入（word embedding）和位置嵌入（position embedding），其中位置嵌入表示在序列中的位置。在每一个位置以词嵌入和位置嵌入的和作为该位置的输入向量。单词的词嵌入通常通过对单词的独热向量进行一个线性变化得到，即用一个矩阵乘以独热向量，矩阵称为词嵌入矩阵。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&emsp;&emsp;根据书中第481页关于Transformer编码器计算公式：\n",
    "> &emsp;&emsp;在编码器的输入层通过线性变换获得单词的词嵌入。\n",
    "> $$\n",
    "e = W_e \\cdot w \\tag{26.26}\n",
    "$$\n",
    "> 其中，$w$是单词的独热向量，$e$是单词的词嵌入，$W_e$是嵌入矩阵。嵌入矩阵在学习中自动获得。  \n",
    "> &emsp;&emsp;编码器的输入层的每一个位置的输入向量是\n",
    "$$\n",
    "e + p \\tag{26.27}\n",
    "$$\n",
    "其中，$e$是该位置的词嵌入，$p$是该位置的位置嵌入。  \n",
    "> &emsp;&emsp;编码器的每一层的每一个位置的前馈网络是\n",
    "> $$\n",
    "\\text{ffn} (z) = W_2 \\text{relu} (W_1 z + b_1) + b_2 \\tag{26.28}\n",
    "$$\n",
    "其中，$W_1$和$W_2$是权重矩阵，$b_1$和$b_2$是偏置向量。  \n",
    "> &emsp;&emsp;编码器的每一层的每一个位置的层归一化函数是\n",
    "> $$\n",
    "\\text{norm} (z) = \\gamma \\frac{z - u \\cdot \\boldsymbol{1}}{\\sqrt{\\sigma^2 + \\varepsilon}} + \\beta \\cdot \\boldsymbol{1}\n",
    "$$\n",
    "> 其中，$u$是均值，$\\sigma^2$是方差，$\\gamma$和$\\beta$是参数，$\\varepsilon$是常量。  \n",
    "> &emsp;&emsp;编码器的输入层的计算可以写作\n",
    "> $$\n",
    "H_E^{(0)} = E_E + P_E \\tag{26.31}\n",
    "$$\n",
    "> &emsp;&emsp;编码器的第$l$个编码器的多头自注意力子层和前馈网络子层计算可以写作\n",
    "> $$\n",
    "Z_E^{(l)} = \\text{norm} (H_E^{(l - 1)} + \\text{multi_attend} (H_E^{(l - 1)}, H_E^{(l - 1)}, H_E^{(l - 1)})) \\tag{26.32}\n",
    "$$\n",
    "> $$\n",
    "H_E^{(l)} = \\text{norm} (Z_E^{(l)} + \\text{ffn} (Z_E^{(l)})) \\tag{26.33}\n",
    "$$\n",
    "> 其中，$H_E^{(l)}$是第$l$个编码层的所有位置的输出，$H_E^{(l - 1)}$是所有位置的输入，$Z_E^{(l)}$是中间结果；$\\text{ffn}()$和$\\text{norm}()$的计算针对矩阵的每一列，$\\text{multi_attend()}$的计算针对矩阵整体进行。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**第3步：比较BERT与Transformer编码器在模型上的异同**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 相同点：\n",
    "    1. 两者都由多个Transformer块组成，每个块包含多头自注意力，前馈网络和层归一化。 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 不同点：\n",
    "    1. BERT模型在Transformer模型的基础上添加了掩码语言模型和下句预测任务。\n",
    "    2. BERT模型在训练的时候会在其后添加线性层和softmax层，用于预测掩码语言模型和下句预测任务；Transformer编码器则是直接和Transformer解码器连接，用于预测序列的下一个单词。\n",
    "    3. BERT模型中输入序列的嵌入由词嵌入、位置嵌入、区别前后单词的标记序列的和组成；Transformer编码器模型的输入序列的嵌入由词嵌入、位置嵌入的和组成。"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "c50c7698ff25eb1d7dce4c52e3d5cc14b3b23d6a97d4fb70aad8c815eba6f63e"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "273.188px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
